home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 7 / Night Owl Shareware (NOPV7)(Night Owl Publisher Inc.)(1992).bin / 038a / bash1_12.arj / BASH1-12.TAR / bash-1.12 / builtins / setattr.def < prev    next >
Text File  |  1991-10-15  |  6KB  |  239 lines
  1. This file is setattr.def, from which is created setattr.c.
  2. It implements the builtins "export" and "readonly", in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES setattr.c
  23.  
  24. #include "../shell.h"
  25.  
  26. $BUILTIN export
  27. $FUNCTION export_builtin
  28. $SHORT_DOC export [-n] [-p] [-f] [name ...]
  29. NAMEs are marked for automatic export to the environment of
  30. subsequently executed commands.  If the -f option is given,
  31. the NAMEs refer to functions.  If no NAMEs are given, or if `-p'
  32. is given, a list of all names that are exported in this shell is
  33. printed.  An argument of `-n' says to remove the export property
  34. from subsequent NAMEs.  An argument of `--' disables further option
  35. processing.
  36. $END
  37.  
  38. /* For each variable name in LIST, make that variable appear in the
  39.    environment passed to simple commands.  If there is no LIST, then
  40.    print all such variables.  An argument of `-n' says to remove the
  41.    exported attribute from variables named in LIST.  An argument of
  42.   -f indicates that the names present in LIST refer to functions. */
  43. export_builtin (list)
  44.      register WORD_LIST *list;
  45. {
  46.   return (set_or_show_attributes (list, att_exported));
  47. }
  48.  
  49. $BUILTIN readonly
  50. $FUNCTION readonly_builtin
  51. $SHORT_DOC readonly [-p] [-f] [name ...]
  52. The given NAMEs are marked readonly and the values of these NAMEs may
  53. not be changed by subsequent assignment.  If the -f option is given,
  54. then functions corresponding to the NAMEs are so marked.  If no
  55. arguments are given, or if `-p' is given, a list of all readonly names
  56. is printed.  An argument of `--' disables further option processing.
  57. $END
  58.  
  59. /* For each variable name in LIST, make that variable readonly.  Given an
  60.    empty LIST, print out all existing readonly variables. */
  61. readonly_builtin (list)
  62.      register WORD_LIST *list;
  63. {
  64.   return (set_or_show_attributes (list, att_readonly));
  65. }
  66.  
  67. /* For each variable name in LIST, make that variable have the specified
  68.    ATTRIBUTE.  An arg of `-n' says to remove the attribute from the the
  69.    remaining names in LIST. */
  70. int
  71. set_or_show_attributes (list, attribute)
  72.      register WORD_LIST *list;
  73.      int attribute;
  74. {
  75.   register SHELL_VAR *var;
  76.   int assign, undo = 0, functions_only = 0;
  77.   extern int array_needs_making;
  78.  
  79.   /* Read arguments from the front of the list. */
  80.   while (list)
  81.     {
  82.       register char *name = list->word->word;
  83.  
  84.       if (strcmp (name, "-n") == 0)
  85.     {
  86.       undo = 1;
  87.       list = list->next;
  88.     }
  89.       else if (strcmp (name, "-f") == 0)
  90.     {
  91.       functions_only = 1;
  92.       list = list->next;
  93.     }
  94.       else if (strcmp (name, "-p") == 0)
  95.     {
  96.       list = list->next;
  97.       continue;
  98.     }
  99.       else if (strcmp (name, "--") == 0)
  100.     {
  101.       list = list->next;
  102.       break;
  103.     }
  104.       else if (*name == '-')
  105.     {
  106.       bad_option (name);
  107.       return (EXECUTION_FAILURE);
  108.     }
  109.       else
  110.     break;
  111.     }
  112.  
  113.   if (list)
  114.     {
  115.       if (attribute & att_exported)
  116.     array_needs_making = 1;
  117.  
  118.       while (list)
  119.     {
  120.       register char *name = list->word->word;
  121.  
  122.       if (functions_only)
  123.         {
  124.           var = find_function (name);
  125.           if (!var)
  126.         {
  127.           builtin_error ("%s: not a function", name);
  128.         }
  129.           else
  130.         {
  131.           if (undo)
  132.             var->attributes &= ~attribute;
  133.           else
  134.             var->attributes |= attribute;
  135.         }
  136.           list = list->next;
  137.           if (attribute == att_exported)
  138.         array_needs_making++;
  139.           continue;
  140.         }
  141.  
  142.       assign = assignment (name);
  143.       if (assign)
  144.         {
  145.           /* This word has already been expanded once with command
  146.          and parameter expansion.  Call do_assignment_no_expand (),
  147.          which does not do command or parameter substitution. */
  148.           do_assignment_no_expand (name);
  149.           name[assign] = '\0';
  150.         }
  151.  
  152.       if (undo)
  153.         {
  154.           var = find_variable (name);
  155.           if (var)
  156.         var->attributes &= ~attribute;
  157.         }
  158.       else
  159.         {
  160.           SHELL_VAR *find_tempenv_variable (), *tv;
  161.  
  162.           if (tv = find_tempenv_variable (name))
  163.         {
  164.           var = bind_variable (tv->name, tv->value);
  165.           dispose_variable (tv);
  166.         }
  167.           else
  168.         var = find_variable (name);
  169.  
  170.           if (!var)
  171.         {
  172.           var = bind_variable (name, (char *)NULL);
  173.           var->attributes |= att_invisible;
  174.         }
  175.  
  176.           var->attributes |= attribute;
  177.         }
  178.       array_needs_making++;    /* XXX */
  179.       list = list->next;
  180.     }
  181.     }
  182.   else
  183.     {
  184.       SHELL_VAR **variable_list;
  185.       register int i;
  186.  
  187.       if ((attribute & att_function) || functions_only)
  188.     {
  189.       variable_list = all_shell_functions ();
  190.       if (attribute != att_function)
  191.         attribute &= ~att_function;    /* so declare -xf works, for example */
  192.     }
  193.       else
  194.     variable_list = all_shell_variables ();
  195.  
  196.       if (variable_list)
  197.     {
  198.       for (i = 0; var = variable_list[i]; i++)
  199.         {
  200.           if ((var->attributes & attribute) && !invisible_p (var))
  201.         {
  202.           char flags[6];
  203.  
  204.           flags[0] = '\0';
  205.  
  206.           if (exported_p (var))
  207.             strcat (flags, "x");
  208.  
  209.           if (readonly_p (var))
  210.             strcat (flags, "r");
  211.  
  212.           if (function_p (var))
  213.             strcat (flags, "f");
  214.  
  215.           if (integer_p (var))
  216.             strcat (flags, "i");
  217.  
  218.           if (flags[0])
  219.             {
  220.               printf ("declare -%s ", flags);
  221.  
  222.               if (!function_p (var))
  223.             printf ("%s=%s\n", var->name, value_cell (var));
  224.               else
  225.             {
  226.               char *named_function_string ();
  227.  
  228.               printf ("%s\n", named_function_string
  229.                   (var->name, function_cell (var), 1));
  230.             }
  231.             }
  232.         }
  233.         }
  234.       free (variable_list);
  235.     }
  236.     }
  237.   return (EXECUTION_SUCCESS);
  238. }
  239.